package com.example.utils;

import android.graphics.Paint;
import android.text.TextUtils;

import com.example.bean.CMinute;
import com.example.bean.FenshiDataResponse;
import com.example.bean.StickData;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.TimeZone;


/**
 * Created by Arvin on 2016/8/4.
 * 分时线等这些图标的通用工具类
 */
public class LineUtil {
    /**
     * 分时时间点的分钟数，对应的点的顺序
     */
   private static Map<String,Integer> map;

    public static void initFenShiPoint(String duration)
    {
        int[] start=null;
        int[] end=null;
        if (duration.contains("|")) {
            String ds[] = duration.split("\\|");
            start=new int[ds.length];
            end=new int[ds.length];
            for(int i=0;i<ds.length;i++)
            {
                String mins[] = ds[i].split("-");
                start[i]=getMin(mins[0]);
                end[i]=getMin(mins[1]);
            }

        } else {
            if (duration.contains("-")) {
                //9:30-11:30
                String mins[] = duration.split("-");
                start=new int[1];
                end=new int[1];
                start[0]=getMin(mins[0]);
                end[1]=getMin(mins[1]);

            }
        }
        int count=0;
        map=new HashMap<>();
        for(int i=0;i<start.length;i++)
        {
            int str=start[i];
            int en=end[i];
            for(int a=str;a<=en;a++)
            {
                map.put(a+"",count);
                count++;
            }

        }

    }
    public static int getIndex(long time)
    {
        int index=0;
        int min=getMin(time);
        Integer a=map.get(min+"");
        if(a==null)
        {
            return 0;
        }
        index=a;

        return  index;
    }
    public static int[] getIndexs(ArrayList<CMinute> minutes)
    {
        if(minutes==null)
        {
            return null;
        }
        int[] indexs=new int[minutes.size()];

        for(int i=0;i<minutes.size();i++)
        {
            indexs[i]=getIndex(minutes.get(i).getTime());
        }

        return  indexs;
    }

    /**
     * 得到分时X坐标在数组中的索引
     * @param index 分时x坐标索引
     * @return 在数组中的索引
     */
    public static int getIndex(int index,int[] indexs)
    {
        int a=-1;
        for(int i=0;i<indexs.length;i++)
        {
            if(index==indexs[i])
            {
                a=i;
            }
        }
        return  a;
    }
    /**
     * 传入时间和分钟如15:00，解析成分钟数，
     *
     * @param minStr 17:00
     * @return
     */
    public static int getMin(String minStr) throws NumberFormatException {
        return Integer.parseInt(minStr.split(":")[0]) * 60 + Integer.parseInt(minStr.split(":")[1]);
    }

    /**
     * 通过long时间获取分钟数
     *
     * @param time
     * @return
     */
    public static int getMin(long time) {

//        Calendar calendar = Calendar.getInstance();
//        calendar.setTimeInMillis(time * 1000);
//        calendar.setTimeZone(TimeZone.getTimeZone(calendar.CHINA_TIME_ZONE));
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
        sdf.setTimeZone(TimeZone.getTimeZone("GMT+8"));
        // return getMin(calendar.get(Calendar.HOUR_OF_DAY) + ":" + calendar.get(Calendar.MINUTE));
        Long timestamp = Long.parseLong(time+"") * 1000;
        String min=sdf.format(new Date(timestamp));
        return  getMin(min);
    }

    /**
     * 根据开收盘的时间，计算网格竖线的x轴坐标
     * @param duration
     * @return
     */
    public static float[] getXByDuration(String duration, float width) {
        if(TextUtils.isEmpty(duration)) return new float[]{};
        int showCount = getShowCount(duration);
        float xUnit = width / (float) showCount;
        ArrayList<Integer> timeMins = getTimesMin(duration);
        if(timeMins.size()== 6) {
            //如果白盘夜盘一起的话，需要画5条竖线（虚实虚实虚）
            float[] result = new float[5];
            //实线1
            result[1] = (timeMins.get(1) - timeMins.get(0)) * xUnit;
            //实线2
            result[3] = (timeMins.get(3) - timeMins.get(0) - (timeMins.get(2) - timeMins.get(1))) * xUnit;
            //虚线1
            result[0] =  result[1] / 2f;
            //虚线2
            result[2] = (result[3] - result[1])/ 2f + result[1];
            //虚线3
            result[4] = (width - result[3]) / 2f + result[3];
            return result;
        } else {
            //如果只有白盘的话，需要画3条竖线（虚实虚）
            float[] result = new float[3];
            //实线1
            result[1] = (timeMins.get(1) - timeMins.get(0)) * xUnit;
            //虚线1
            result[0] =  result[1] / 2f;
            //虚线2
            result[2] =  (width - result[1]) / 2f + result[1];
            return result;
        }
    }

    /**
     * 判断网格是否不规则的网格：即早中晚开盘时间是否一致，不一致的话网格需要重新画
     * @param duration
     * @return
     */
    public static boolean isIrregular(String duration) {
        ArrayList<Integer> timeMins = getTimesMin(duration);
        switch (timeMins.size()) {
            case 2:
                return false;
            case 4:
                return timeMins.get(3) - timeMins.get(2) != timeMins.get(1) - timeMins.get(0);
            case 6:
                return (timeMins.get(3) - timeMins.get(2) != timeMins.get(1) - timeMins.get(0)) || (timeMins.get(3) - timeMins.get(2) != timeMins.get(5) - timeMins.get(4));
        }
        return false;
    }

    /**
     * 获取开盘收盘时间对应的分钟数
     * @param duration
     * @return
     */
    public static ArrayList<Integer> getTimesMin(String duration) {

        ArrayList<String> times = getTimes(duration);
        ArrayList<Integer> mins = new ArrayList<>();
        for(String s : times) {

            int min = getMin(s);
            mins.add(min);
        }
        return mins;
    }
    /**
     * 计算当前周期时间
     * 当前时间-(当前时间-开始时间段)%周期+周期
     * @param time 时间描述
     * @param ctime 当前时间
     * @param size 1 5 10分钟周期
     * @return
     */
    public  static long countTime(String time,long ctime,int size)
    {
        StickData sd=new StickData();
        //Log.e("ctime",sd.getTime3(ctime));
        long czhouqi=0;
        boolean istimeend=isTimeEnd(time,ctime);
        if(istimeend)
        {
            return ctime;
        }
        if(size==24)
        {

            return ctime;
        }
        long cha=getStartTime(time,ctime,size);

        czhouqi=ctime-cha%size*60+size*60;
        czhouqi=czhouqi-czhouqi%60;
        //如果大于收盘时间 直接返回收盘时间
        if(size!=24) {
            czhouqi = getJiaoYi(time, czhouqi);
        }
        //Log.e("time",sd.getTime3(czhouqi)+"");
        return  czhouqi;
    }
    /** 用来计算历史k线最后一个点
     * 计算当前周期时间
     * 当前时间-(当前时间-开始时间段)%周期+周期
     * @param time 时间描述
     * @param ctime 当前时间
     * @param size 1 5 10分钟周期
     * @return
     */
    public  static long countTime2(String time,long ctime,int size)
    {
        StickData sd=new StickData();
        //Log.e("ctime",sd.getTime3(ctime));
        long czhouqi=0;
        if(size==24)
        {

            return ctime;
        }
        long cha=getStartTime(time,ctime,size);
        if(cha%size==0)
        {
            czhouqi=ctime-cha%size*60;
        }
        else
        {
            czhouqi=ctime-cha%size*60+size*60;
        }

        czhouqi=czhouqi-czhouqi%60;
        //如果大于收盘时间 直接返回收盘时间
        czhouqi=getJiaoYi(time,czhouqi);

        //Log.e("time",sd.getTime3(czhouqi)+"");
        return  czhouqi;
    }
    public static boolean isTimeEnd(String time,long ctime)
    {
        boolean b=false;
        long cha=0;
        StickData sd=new StickData();
        sd.setTime(ctime);
        int cmin= LineUtil.getMin(ctime);
        int[] start=null;
        int[] end=null;
        //停盘的 duration 9:30-11:30|13:00-15:00"
        //我这里全部转换成分钟
        String duration = time;
        if (duration.contains("|")) {
            String ds[] = duration.split("\\|");
            start=new int[ds.length];
            end=new int[ds.length];
            for(int i=0;i<ds.length;i++)
            {
                String mins[] = ds[i].split("-");
                start[i]=LineUtil.getMin(mins[0]);
                end[i]=LineUtil.getMin(mins[1]);
            }

        } else {
            if (duration.contains("-")) {
                //9:30-11:30
                String mins[] = duration.split("-");
                start=new int[1];
                end=new int[1];
                start[0]=LineUtil.getMin(mins[0]);
                end[1]=LineUtil.getMin(mins[1]);

            }
        }

        for(int i=0;i<start.length;i++)
        {
            if(cmin>=start[i]&&cmin<=end[i])
            {
                if(cmin==end[i])
                {
                    b=true;
                }
            }
        }


        return  b;
    }
    /**
     * 得到当前时间 开始的时间段 相差的分钟数
     * @param time 时间描述
     * @param ctime 当前时间
     * @return
     */
    public static long getStartTime(String time,long ctime,int size)
    {
        long cha=0;
        StickData sd=new StickData();
        sd.setTime(ctime);
        int cmin= LineUtil.getMin(ctime);
        int[] start=null;
        int[] end=null;
        //停盘的 duration 9:30-11:30|13:00-15:00"
        //我这里全部转换成分钟
        String duration = time;
        if (duration.contains("|")) {
            String ds[] = duration.split("\\|");
            start=new int[ds.length];
            end=new int[ds.length];
            for(int i=0;i<ds.length;i++)
            {
                String mins[] = ds[i].split("-");
                start[i]=LineUtil.getMin(mins[0]);
                end[i]=LineUtil.getMin(mins[1]);
            }

        } else {
            if (duration.contains("-")) {
                //9:30-11:30
                String mins[] = duration.split("-");
                start=new int[1];
                end=new int[1];
                start[0]=LineUtil.getMin(mins[0]);
                end[1]=LineUtil.getMin(mins[1]);

            }
        }

        for(int i=0;i<start.length;i++)
        {
            if(cmin>=start[i]&&cmin<=end[i])
            {
                cha=cmin-start[i];
                long l1=cmin-cha%size+size;
                if(l1>end[i])
                {
                    cha=end[i]-start[i];
                }
            }
        }
        return  cha;
    }
    /**
     * 得到交易时间内的时间
     * @param time 交易时间段
     * @param ctime 计算出的时间
     * @return
     */
    public  static long getJiaoYi(String time,long ctime)
    {
        int[] start=null;
        int[] end=null;
        //停盘的 duration 9:30-11:30|13:00-15:00"
        //我这里全部转换成分钟
        String duration = time;
        if (duration.contains("|")) {
            String ds[] = duration.split("\\|");
            start=new int[ds.length];
            end=new int[ds.length];
            for(int i=0;i<ds.length;i++)
            {
                String mins[] = ds[i].split("-");
                start[i]=LineUtil.getMin(mins[0]);
                end[i]=LineUtil.getMin(mins[1]);
            }

        } else {
            if (duration.contains("-")) {
                //9:30-11:30
                String mins[] = duration.split("-");
                start=new int[1];
                end=new int[1];
                start[0]=LineUtil.getMin(mins[0]);
                end[1]=LineUtil.getMin(mins[1]);

            }
        }
        long cmin=getMin(ctime);
        long endmin=0;
        for(int i=0;i<start.length;i++)
        {
            if(cmin>=start[i]&&cmin<=end[i])
            {
                return ctime;
            }

        }

        long min=getMin(ctime);
        long tem=ctime-min*60+end[end.length-1]*60;


        return  tem;
    }
    /**
     * 得到结束的分钟数
     * @param time
     * @return
     */
    public static  long  getEndMin(String time)
    {
        int[] start=null;
        int[] end=null;
        //停盘的 duration 9:30-11:30|13:00-15:00"
        //我这里全部转换成分钟
        String duration = time;
        if (duration.contains("|")) {
            String ds[] = duration.split("\\|");
            start=new int[ds.length];
            end=new int[ds.length];
            for(int i=0;i<ds.length;i++)
            {
                String mins[] = ds[i].split("-");
                start[i]=LineUtil.getMin(mins[0]);
                end[i]=LineUtil.getMin(mins[1]);
            }

        } else {
            if (duration.contains("-")) {
                //9:30-11:30
                String mins[] = duration.split("-");
                start=new int[1];
                end=new int[1];
                start[0]=LineUtil.getMin(mins[0]);
                end[1]=LineUtil.getMin(mins[1]);

            }
        }
        long min=end[end.length-1];
        return  min;
    }
    /**
     * 获取分时线下的时间，需要展示的点数目
     *
     * @param duration 如9:00-11:00|13:00-15:00
     * @return 上面的是4小时，返回240
     */
    public static int getShowCount(String duration) {
        ArrayList<Integer> mins = getTimesMin(duration);
        switch (mins.size()) {
            case 2:
                return mins.get(1) - mins.get(0);
            case 4:
                return (mins.get(3) - mins.get(2)) + (mins.get(1) - mins.get(0));
            case 6:
                return (mins.get(5) - mins.get(4)) + (mins.get(3) - mins.get(2)) + (mins.get(1) - mins.get(0));
            case 8:
                return (mins.get(7) - mins.get(6)) + (mins.get(5) - mins.get(4)) +(mins.get(3) - mins.get(2)) + (mins.get(1) - mins.get(0));
        }
        return 242;
    }
    public static String TimeStamp2Date(String timestampString) {

        String formats   = "yyyy-MM-dd HH:mm:ss";
        Long timestamp = Long.parseLong(timestampString) * 1000;
        String date = new SimpleDateFormat(formats, Locale.CHINA).format(new Date(timestamp));

        return date;
    }
    public static ArrayList<CMinute> getAllFenshiData3(FenshiDataResponse response)
    {
        ArrayList<CMinute> fsDatasTemp = new ArrayList<CMinute>();
        if(response.getData() == null || response.getData().size() == 0)
            return  fsDatasTemp;

        if (response.getParam() == null) return fsDatasTemp;
        int[] start=null;
        int[] end=null;
        //停盘的 duration 9:30-11:30|13:00-15:00"
        //我这里全部转换成分钟
        String duration = response.getParam().getDuration();
        if (duration.contains("|")) {
            String ds[] = duration.split("\\|");
            start=new int[ds.length];
            end=new int[ds.length];
            for(int i=0;i<ds.length;i++)
            {
                String mins[] = ds[i].split("-");
                start[i]=getMin(mins[0]);
                end[i]=getMin(mins[1]);
            }

        } else {
            if (duration.contains("-")) {
                //9:30-11:30
                String mins[] = duration.split("-");
                start=new int[1];
                end=new int[1];
                start[0]=getMin(mins[0]);
                end[1]=getMin(mins[1]);

            }
        }
        int drawCount = 0;
        for(int i=0;i<start.length;i++)
        {
            drawCount+=(end[i]-start[i]);
        }
        int index=0;
        boolean finish=false;
        /**
         * 是否隔夜了
         */
        boolean isGeYe=false;
        //23:59 的分钟数
        int min24=23*60+59;
        //第1个分钟数
        int firstMin = getMin(response.getData().get(0).getTime());
        //最后1分钟分钟数
        int last=getMin(response.getData().get(response.getData().size()-1).getTime());
        if(last<firstMin)
        {
            isGeYe=true;
        }
        double price=0;
        double price_are=0;

        //判断是否有多余数据,找到返回的数据第一个开始的时间
//        for(int i=0;i<response.getData().size();i++)
//        {
//            int tem = getMin(response.getData().get(i).getTime());
//            if(start[0]<=tem&&tem<=end[0])
//            {
//                index=i;
//                break;
//            }
//        }
        for(int i=0;i<start.length;i++)
        {
            int str=start[i];
            int en=end[i];

            if(fsDatasTemp.size()==0)
            {
                price=response.getParam().getLast();
                price_are=price;
            }
            else
            {
                price=fsDatasTemp.get(fsDatasTemp.size()-1).price;
                price_are=fsDatasTemp.get(fsDatasTemp.size()-1).average;
            }

            ArrayList<CMinute> list= new ArrayList<CMinute>();
            //a 当前分钟数
            for(int a=str;a<=en;a++)
            {

                CMinute cm=new CMinute();

                //服务器返回数据的第一个数据时间
                long firstLongTime = response.getData().get(0).getTime();
                cm.setTime(firstLongTime - (firstMin-a) * 60);
                cm.setPrice(price);
                cm.setAverage(price_are);

                int cmin =0;
                for(int b=index;b<response.getData().size();b++)
                {
                    cmin = getMin(response.getData().get(b).getTime());
                    if(cmin==a)
                    {
                        cm= response.getData().get(b);
                        index=b+1;

                        break;
                    }
                    else if(cmin>a)
                    {
                        break;
                    }

                    else
                    {
                        break;
                    }

                }
                //  //如果到最后一分钟分时了
                if(cmin==last)
                {
                    finish=true;
                    break;
                }
                //如果到最后一分钟分时了
                if(a>last&&a>firstMin&&last>start[0])
                {
                    finish=true;
                    break;
                }
                //如果到最后一分钟分时了
                if(last<start[0]&&a>last&&a<start[0])
                {
                    finish=true;
                    break;
                }


                list.add(cm);
                price=cm.getPrice();
                price_are=cm.getAverage();


            }

            if(list.size()==0)
            {

            }

            fsDatasTemp.addAll(list);
            if(finish)
            {
                break;
            }
        }

//
//        fsDatasTemp.addAll(response.getData());
//        int firstMin = getMin(fsDatasTemp.get(0).getTime());
//        String s0=TimeStamp2Date(fsDatasTemp.get(0).getTime()+"");
//        while (firstMin <start[0] && fsDatasTemp != null && fsDatasTemp.size() > 1) {
//            fsDatasTemp.remove(0);
//            response.getData().remove(0);
//            firstMin = getMin(fsDatasTemp.get(0).getTime());
//        }
//
//        //服务器返回数据的第一个数据时间
//        long firstLongTime = fsDatasTemp.get(0).getTime();
//        for (int i = 0; i < response.getData().size(); i++) {
//            if (i == 0) {
//                //1,先补全第一点到开盘时间中间的点
//                int div = firstMin - start[0] - 1;
//                if (div >= 1) {
//                    for (int j = 0; j <= div; j++) {
//                        int min = getMin(firstLongTime - (j + 1) * 60);
//                        if(min>end[0]||min<start[0])
//                        {
//                            continue;
//                        }
//                        CMinute temp = new CMinute();
//                        temp.setTime(firstLongTime - (j + 1) * 60);
//                        temp.setPrice(response.getParam().getLast());
//                        fsDatasTemp.add(0, temp);
//                    }
//                }
//            } else {
//                if(1==1)
//                {
//                    continue;
//                }
//                CMinute currentObject = response.getData().get(i);
//                CMinute beforeObject = response.getData().get(i - 1);
//                String s1=TimeStamp2Date(currentObject.getTime()+"");
//                String s2=TimeStamp2Date(beforeObject.getTime()+"");
//                int currentMin = getMin(currentObject.getTime());
//                int beforeMin = getMin(beforeObject.getTime());
//                //当前时间 比上一次的时间要大2分钟   正常数据的时候是1分钟
//                int div = currentMin - beforeMin - 1;
//                //没有休盘时间或者是 在休盘时间外
//                if (isTime(currentMin,start,end)) {
//                    for (int j = 0; j < div; j++) {
//                        CMinute temp = (CMinute) beforeObject.clone();
//                        temp.setTime(beforeObject.getTime() + ((j + 1) * 60));
//                        temp.setCount(0);
//                        temp.setMoney(0);
//                        int tempMin = beforeMin + (j + 1);
//                        fsDatasTemp.add(i + fsDatasTemp.size() - response.getData().size() + 1, temp);
//
//                    }
//                }
//            }
//        }
        //20160801 解析后的时间有时错乱了，需要对时间进行排序
        //TODO 此处需要优化，应该从循环中发现哪里添加错误，而不是简单的进行排序，排序反而会消耗内存、时间，需要修改
//        Collections.sort(fsDatasTemp, new Comparator<CMinute>() {
//            @Override
//            public int compare(CMinute cMinute, CMinute t1) {
//                return new Long(cMinute.getTime()).compareTo(new Long(t1.getTime()));
//            }
//        });
        return fsDatasTemp;
    }


    public static ArrayList<CMinute> getAllFenshiData4(FenshiDataResponse response)
    {
        ArrayList<CMinute> fsDatasTemp = new ArrayList<CMinute>();
        if(response.getData() == null || response.getData().size() == 0)
            return  fsDatasTemp;

        if (response.getParam() == null) return fsDatasTemp;
        int[] start=null;
        int[] end=null;
        //停盘的 duration 9:30-11:30|13:00-15:00"
        //我这里全部转换成分钟
        String duration = response.getParam().getDuration();
        if (duration.contains("|")) {
            String ds[] = duration.split("\\|");
            start=new int[ds.length];
            end=new int[ds.length];
            for(int i=0;i<ds.length;i++)
            {
                String mins[] = ds[i].split("-");
                start[i]=getMin(mins[0]);
                end[i]=getMin(mins[1]);
            }

        } else {
            if (duration.contains("-")) {
                //9:30-11:30
                String mins[] = duration.split("-");
                start=new int[1];
                end=new int[1];
                start[0]=getMin(mins[0]);
                end[1]=getMin(mins[1]);

            }
        }
        int drawCount = 0;
        for(int i=0;i<start.length;i++)
        {
            drawCount+=(end[i]-start[i]);
        }
        int index=0;
        boolean finish=false;
        /**
         * 是否隔夜了
         */
        boolean isGeYe=false;
        //23:59 的分钟数
        int min24=23*60+59;
        //第1个分钟数
        int firstMin = getMin(response.getData().get(0).getTime());
        //最后1分钟分钟数
        int last=getMin(response.getData().get(response.getData().size()-1).getTime());
        if(last<firstMin)
        {
            isGeYe=true;
        }
        double price=0;
        double price_are=0;

        //判断是否有多余数据,找到返回的数据第一个开始的时间
//        for(int i=0;i<response.getData().size();i++)
//        {
//            int tem = getMin(response.getData().get(i).getTime());
//            if(start[0]<=tem&&tem<=end[0])
//            {
//                index=i;
//                break;
//            }
//        }
        for(int i=0;i<start.length;i++)
        {
            int str=start[i];
            int en=end[i];

            if(fsDatasTemp.size()==0)
            {
                price=response.getParam().getLast();
                price_are=price;
            }
            else
            {
                price=fsDatasTemp.get(fsDatasTemp.size()-1).price;
                price_are=fsDatasTemp.get(fsDatasTemp.size()-1).average;
            }

            ArrayList<CMinute> list= new ArrayList<CMinute>();
            //a 当前分钟数
            for(int a=str;a<=en;a++)
            {

                CMinute cm=null;
                int mIndex=getCMinuteIndex(a,response.getData(),index);
                if(mIndex>-1)
                {
                    cm= response.getData().get(mIndex);
                    index=mIndex;
                }
                else
                {
                    cm=new CMinute();
                    //服务器返回数据的第一个数据时间
                    long firstLongTime = response.getData().get(0).getTime();
                    cm.setTime(firstLongTime - (firstMin-a) * 60);
                    cm.setPrice(price);
                    cm.setAverage(price_are);
                }


//                int cmin =0;
//                for(int b=index;b<response.getData().size();b++)
//                {
//                    cmin = getMin(response.getData().get(b).getTime());
//                    if(cmin==a)
//                    {
//                        cm= response.getData().get(b);
//                        index=b+1;
//
//                        break;
//                    }
//                    else if(cmin>a)
//                    {
//                        break;
//                    }
//
//                    else
//                    {
//                        break;
//                    }
//
//                }
                //  //如果到最后一分钟分时了
//                if(cmin==last)
//                {
//                    finish=true;
//                    break;
//                }
                //如果到最后一分钟分时了
//                if(a>last&&a>firstMin&&last>start[0])
//                {
//                    finish=true;
//                    break;
//                }
                //如果到最后一分钟分时了
//                if(last<start[0]&&a>last&&a<start[0])
//                {
//                    finish=true;
//                    break;
//                }


                list.add(cm);
                price=cm.getPrice();
                price_are=cm.getAverage();

                if(a==last)
                {
                    finish=true;
                    break;
                }
            }

            if(list.size()==0)
            {

            }

            fsDatasTemp.addAll(list);
            if(finish)
            {
                break;
            }
        }


        return fsDatasTemp;
    }

    /**
     * 得到当前分钟数的分时数据的索引
     * @param min 分钟数
     * @param list 所有的数据
     *
     * @param start 开始的索引
     * @return
     */
    private static int getCMinuteIndex(int min, List<CMinute> list, int start)
    {

        for(int i=start;i<list.size();i++)
        {
            int cmin = getMin(list.get(i).getTime());
            if(cmin==min)
            {
                return i;
            }
        }

        return  -1;
    }
    /**
     *
     * @param start 开始分钟
     * @param end  结束分钟
     * @param response
     */
    private static ArrayList<CMinute> selectData(double price,int start,int end,FenshiDataResponse response,int index)
    {
        ArrayList<CMinute> fsDatasTemp = new ArrayList<CMinute>();
        for(int i=start;i<=end;i++)
        {

            CMinute cm= selectData2(price,i,response,index);
            if(cm==null)
            {
                break;
            }
            fsDatasTemp.add(cm);

        }
        if(fsDatasTemp.size()==0)
        {
            return null;
        }
        return fsDatasTemp;
    }
    private static CMinute selectData2(double price,int min,FenshiDataResponse response,int index)
    {
        CMinute cm=new CMinute();
        int firstMin = getMin(response.getData().get(0).getTime());
        //服务器返回数据的第一个数据时间
        long firstLongTime = response.getData().get(0).getTime();
        cm.setTime(firstLongTime - (firstMin-min) * 60);
        cm.setPrice(price);

        int last=getMin(response.getData().get(response.getData().size()-1).getTime());

        for(int a=index;a<response.getData().size();a++)
        {
            int cmin = getMin(response.getData().get(a).getTime());
            if(cmin==min)
            {
                return response.getData().get(a);
            }

        }
        if(min>last&&min>firstMin)
        {
            return null;
        }
        return cm;
    }
    /**
     * 补全分时图中缺失的点，如某个时间段没有数据，则该时间段都取前一条数据的值
     *
     * @param response
     * @return
     */
    public static ArrayList<CMinute> getAllFenshiData2(FenshiDataResponse response) {
        ArrayList<CMinute> fsDatasTemp = new ArrayList<CMinute>();
        if(response.getData() == null || response.getData().size() == 0)
            return  fsDatasTemp;
        int nightStartMin = 0, nightStopMin = 0;
        int morningStartMin = 0, morningStopMin = 0, afternoonStartMin = 0, afternoonStopMin = 0;

        if (response.getParam() == null) return fsDatasTemp;
        int[] start=null;
        int[] end=null;
        //停盘的 duration 9:30-11:30|13:00-15:00"
        //我这里全部转换成分钟
        String duration = response.getParam().getDuration();
        if (duration.contains("|")) {
            String ds[] = duration.split("\\|");
            start=new int[ds.length];
            end=new int[ds.length];
            for(int i=0;i<ds.length;i++)
            {
                String mins[] = ds[i].split("-");
                start[i]=getMin(mins[0]);
                end[i]=getMin(mins[1]);
            }
//            if (ds[0].contains("-")) {
//                //9:30-11:30
//                String mins[] = ds[0].split("-");
//                morningStartMin = getMin(mins[0]);
//                morningStopMin = getMin(mins[1]);
//
//            }
//            if (ds[1].contains("-")) {
//                //13:00-15:00
//                String mins[] = ds[1].split("-");
//                afternoonStartMin = getMin(mins[0]);
//                afternoonStopMin = getMin(mins[1]);
//
//            }
//            if (ds.length == 3) {
//                String mins[] = ds[2].split("-");
//                nightStartMin = getMin(mins[0]);
//                nightStopMin = getMin(mins[1]);
//            }
        } else {
            if (duration.contains("-")) {
                //9:30-11:30
                String mins[] = duration.split("-");
                //morningStartMin = getMin(mins[0]);
                //afternoonStopMin = getMin(mins[1]);
                start=new int[1];
                end=new int[1];
                start[0]=getMin(mins[0]);
                end[1]=getMin(mins[1]);

            }
        }
        int drawCount = 0;
        //是否有夜盘
//        boolean hasNight = nightStartMin > 0;
//        if (!hasNight)
//            drawCount = afternoonStopMin - morningStartMin - (afternoonStartMin - morningStopMin);
//            //drawCount = morningStopMin - morningStartMin +(afternoonStopMin - afternoonStartMin);
//        else
//            drawCount = nightStopMin - morningStartMin - (nightStartMin - afternoonStopMin) - (afternoonStartMin - morningStopMin);

        for(int i=0;i<start.length;i++)
        {
            drawCount+=(end[i]-start[i]);
        }

        fsDatasTemp.addAll(response.getData());
        int firstMin = getMin(fsDatasTemp.get(0).getTime());
        String s0=TimeStamp2Date(fsDatasTemp.get(0).getTime()+"");
        while (firstMin <start[0] && fsDatasTemp != null && fsDatasTemp.size() > 1) {
            fsDatasTemp.remove(0);
            response.getData().remove(0);
            firstMin = getMin(fsDatasTemp.get(0).getTime());
        }

        //服务器返回数据的第一个数据时间
        long firstLongTime = fsDatasTemp.get(0).getTime();
        for (int i = 0; i < response.getData().size(); i++) {
            if (i == 0) {
                //1,先补全第一点到开盘时间中间的点
                int div = firstMin - start[0] - 1;
                if (div >= 1) {
                    for (int j = 0; j <= div; j++) {
                        int min = getMin(firstLongTime - (j + 1) * 60);
//                        if(hasNight) {
//                            if((min > morningStopMin && min < afternoonStartMin) || (min > afternoonStopMin && min < nightStartMin))
//                                continue;
//                        }else {
//                            if(min > morningStopMin && min < afternoonStartMin && afternoonStartMin != 0)
//                                continue;
//                        }
                        if(min>end[0]||min<start[0])
                        {
                            continue;
                        }
                        CMinute temp = new CMinute();
                        temp.setTime(firstLongTime - (j + 1) * 60);
                        temp.setPrice(response.getParam().getLast());
                        fsDatasTemp.add(0, temp);
                    }
                }
            } else {
                if(1==1)
                {
                    continue;
                }
                CMinute currentObject = response.getData().get(i);
                CMinute beforeObject = response.getData().get(i - 1);
                String s1=TimeStamp2Date(currentObject.getTime()+"");
                String s2=TimeStamp2Date(beforeObject.getTime()+"");
                int currentMin = getMin(currentObject.getTime());
                int beforeMin = getMin(beforeObject.getTime());
                //当前时间 比上一次的时间要大2分钟   正常数据的时候是1分钟
                int div = currentMin - beforeMin - 1;
                //没有休盘时间或者是 在休盘时间外
                if (isTime(currentMin,start,end)) {
                    for (int j = 0; j < div; j++) {
                        CMinute temp = (CMinute) beforeObject.clone();
                        temp.setTime(beforeObject.getTime() + ((j + 1) * 60));
                        temp.setCount(0);
                        temp.setMoney(0);
                        int tempMin = beforeMin + (j + 1);
                        fsDatasTemp.add(i + fsDatasTemp.size() - response.getData().size() + 1, temp);
//                        if (morningStopMin > 0) {
//                            //有停盘点
//                            //没有夜盘
//                            if (!hasNight) {
//                                if (tempMin > morningStopMin && tempMin < afternoonStartMin) {
//                                    //正好在停盘时间内
//                                } else {
//                                    fsDatasTemp.add(i + fsDatasTemp.size() - response.getData().size() + 1, temp);
//                                }
//                            } else {
//                                //有夜盘
//                                if ((tempMin > morningStopMin && tempMin < afternoonStartMin) || (tempMin > afternoonStopMin && tempMin < nightStartMin)) {
//                                    //正好在停盘时间内
//                                } else {
//                                    fsDatasTemp.add(i + fsDatasTemp.size() - response.getData().size() + 1, temp);
//                                }
//                            }
//
//                        } else {
//                            //没有中间停盘时间
//                            fsDatasTemp.add(i + fsDatasTemp.size() - response.getData().size() + 1, temp);
//                        }
                    }
                }
            }
        }

        //until 画线最后到达的位置
        int until = getMin(response.getParam().getUntil());

        if (until <= end[end.length-1] && fsDatasTemp.size() < drawCount&&1>2) {
            CMinute lasteObject = fsDatasTemp.get(fsDatasTemp.size() - 1);
            int lasteMin = getMin(lasteObject.getTime());
            int div = until - lasteMin - 1;
            if (div >= 1) {
                for (int j = 0; j <= div; j++) {
                    CMinute temp = new CMinute();
                    temp.setTime((lasteObject.getTime() + (j + 1) * 60));
                    temp.setPrice(lasteObject.getPrice());
                    temp.setAverage(lasteObject.getAverage());
                    int tempMin = lasteMin + (j + 1);
                    boolean is=isTime(tempMin,start,end);
                    if(is)
                    {
                        fsDatasTemp.add(fsDatasTemp.size(), temp);
                    }
//                    if (morningStopMin > 0) {
//                        //有停盘点
//                        int tempMin = lasteMin + (j + 1);
//                        if (hasNight) {
//                            if ((tempMin > morningStopMin && tempMin < afternoonStartMin) || (tempMin > afternoonStopMin && tempMin < nightStartMin)) {
//                                //正好在停盘时间内  不添加
//                            } else {
//                                fsDatasTemp.add(fsDatasTemp.size(), temp);
//                            }
//                        } else {
//                            if (tempMin > morningStopMin && tempMin < afternoonStartMin) {
//                                //正好在停盘时间内  不添加
//                            } else {
//                                fsDatasTemp.add(fsDatasTemp.size(), temp);
//                            }
//                        }

//                    }

                }
            }
        }
        //20160801 解析后的时间有时错乱了，需要对时间进行排序
        //TODO 此处需要优化，应该从循环中发现哪里添加错误，而不是简单的进行排序，排序反而会消耗内存、时间，需要修改
        Collections.sort(fsDatasTemp, new Comparator<CMinute>() {
            @Override
            public int compare(CMinute cMinute, CMinute t1) {
                return new Long(cMinute.getTime()).compareTo(new Long(t1.getTime()));
            }
        });
        return fsDatasTemp;
    }
    public static boolean isTime(int currentMin,int []start,int []end)
    {
        boolean b1=false;
        for(int i=0;i<start.length;i++)
        {
            if(currentMin>=start[i]&&currentMin<=end[i])
            {
                b1=true;
                break;
            }
        }
        return b1;
    }

    /**
     * 补全分时图中缺失的点，如某个时间段没有数据，则该时间段都取前一条数据的值
     *
     * @param response
     * @return
     */
    public static ArrayList<CMinute> getAllFenshiData(FenshiDataResponse response) {
        ArrayList<CMinute> fsDatasTemp = new ArrayList<CMinute>();
        if(response.getData() == null || response.getData().size() == 0)
            return  fsDatasTemp;
        int nightStartMin = 0, nightStopMin = 0;
        int morningStartMin = 0, morningStopMin = 0, afternoonStartMin = 0, afternoonStopMin = 0;
        if (response.getParam() == null) return fsDatasTemp;
        //停盘的 duration 9:30-11:30|13:00-15:00"
        //我这里全部转换成分钟
        String duration = response.getParam().getDuration();
        if (duration.contains("|")) {
            String ds[] = duration.split("\\|");
            if (ds[0].contains("-")) {
                //9:30-11:30
                String mins[] = ds[0].split("-");
                morningStartMin = getMin(mins[0]);
                morningStopMin = getMin(mins[1]);

            }
            if (ds[1].contains("-")) {
                //13:00-15:00
                String mins[] = ds[1].split("-");
                afternoonStartMin = getMin(mins[0]);
                afternoonStopMin = getMin(mins[1]);

            }
            if (ds.length == 3) {
                String mins[] = ds[2].split("-");
                nightStartMin = getMin(mins[0]);
                nightStopMin = getMin(mins[1]);
            }
        } else {
            if (duration.contains("-")) {
                //9:30-11:30
                String mins[] = duration.split("-");
                morningStartMin = getMin(mins[0]);
                afternoonStopMin = getMin(mins[1]);

            }
        }
        int drawCount = 0;
        //是否有夜盘
        boolean hasNight = nightStartMin > 0;
        if (!hasNight)
            drawCount = afternoonStopMin - morningStartMin - (afternoonStartMin - morningStopMin);
            //drawCount = morningStopMin - morningStartMin +(afternoonStopMin - afternoonStartMin);
        else
            drawCount = nightStopMin - morningStartMin - (nightStartMin - afternoonStopMin) - (afternoonStartMin - morningStopMin);
        fsDatasTemp.addAll(response.getData());
        int firstMin = getMin(fsDatasTemp.get(0).getTime());
        String s0=TimeStamp2Date(fsDatasTemp.get(0).getTime()+"");
        while (firstMin < morningStartMin && fsDatasTemp != null && fsDatasTemp.size() > 1) {
            fsDatasTemp.remove(0);
            response.getData().remove(0);
            firstMin = getMin(fsDatasTemp.get(0).getTime());
        }

        //服务器返回数据的第一个数据时间
        long firstLongTime = fsDatasTemp.get(0).getTime();
        for (int i = 0; i < response.getData().size(); i++) {
            if (i == 0) {
                //1,先补全第一点到开盘时间中间的点
                int div = firstMin - morningStartMin - 1;
                if (div >= 1) {
                    for (int j = 0; j <= div; j++) {
                        int min = getMin(firstLongTime - (j + 1) * 60);
                        if(hasNight) {
                            if((min > morningStopMin && min < afternoonStartMin) || (min > afternoonStopMin && min < nightStartMin))
                                continue;
                        }else {
                            if(min > morningStopMin && min < afternoonStartMin && afternoonStartMin != 0)
                                continue;
                        }
                        CMinute temp = new CMinute();
                        temp.setTime(firstLongTime - (j + 1) * 60);
                        temp.setPrice(response.getParam().getLast());
                        fsDatasTemp.add(0, temp);
                    }
                }
            } else {
                CMinute currentObject = response.getData().get(i);
                CMinute beforeObject = response.getData().get(i - 1);
                String s1=TimeStamp2Date(currentObject.getTime()+"");
                String s2=TimeStamp2Date(beforeObject.getTime()+"");
                int currentMin = getMin(currentObject.getTime());
                int beforeMin = getMin(beforeObject.getTime());
                //当前时间 比上一次的时间要大2分钟   正常数据的时候是1分钟
                int div = currentMin - beforeMin - 1;
                //没有休盘时间或者是 在休盘时间外
                if (morningStopMin == 0 || currentMin <= morningStopMin || currentMin >= afternoonStartMin) {
                    for (int j = 0; j < div; j++) {
                        CMinute temp = (CMinute) beforeObject.clone();
                        temp.setTime(beforeObject.getTime() + ((j + 1) * 60));
                        temp.setCount(0);
                        temp.setMoney(0);
                        int tempMin = beforeMin + (j + 1);
                        if (morningStopMin > 0) {
                            //有停盘点
                            //没有夜盘
                            if (!hasNight) {
                                if (tempMin > morningStopMin && tempMin < afternoonStartMin) {
                                    //正好在停盘时间内
                                } else {
                                    fsDatasTemp.add(i + fsDatasTemp.size() - response.getData().size() + 1, temp);
                                }
                            } else {
                                //有夜盘
                                if ((tempMin > morningStopMin && tempMin < afternoonStartMin) || (tempMin > afternoonStopMin && tempMin < nightStartMin)) {
                                    //正好在停盘时间内
                                } else {
                                    fsDatasTemp.add(i + fsDatasTemp.size() - response.getData().size() + 1, temp);
                                }
                            }

                        } else {
                            //没有中间停盘时间
                            fsDatasTemp.add(i + fsDatasTemp.size() - response.getData().size() + 1, temp);
                        }
                    }
                }
            }
        }

        //until 画线最后到达的位置
        int until = getMin(response.getParam().getUntil());
        if (until <= (hasNight ? nightStopMin : afternoonStopMin) && fsDatasTemp.size() < drawCount) {
            CMinute lasteObject = fsDatasTemp.get(fsDatasTemp.size() - 1);
            int lasteMin = getMin(lasteObject.getTime());
            int div = until - lasteMin - 1;
            if (div >= 1) {
                for (int j = 0; j <= div; j++) {
                    CMinute temp = new CMinute();
                    temp.setTime((lasteObject.getTime() + (j + 1) * 60));
                    temp.setPrice(lasteObject.getPrice());
                    temp.setAverage(lasteObject.getAverage());
                    if (morningStopMin > 0) {
                        //有停盘点
                        int tempMin = lasteMin + (j + 1);
                        if (hasNight) {
                            if ((tempMin > morningStopMin && tempMin < afternoonStartMin) || (tempMin > afternoonStopMin && tempMin < nightStartMin)) {
                                //正好在停盘时间内  不添加
                            } else {
                                fsDatasTemp.add(fsDatasTemp.size(), temp);
                            }
                        } else {
                            if (tempMin > morningStopMin && tempMin < afternoonStartMin) {
                                //正好在停盘时间内  不添加
                            } else {
                                fsDatasTemp.add(fsDatasTemp.size(), temp);
                            }
                        }

                    }

                }
            }
        }
        //20160801 解析后的时间有时错乱了，需要对时间进行排序
        //TODO 此处需要优化，应该从循环中发现哪里添加错误，而不是简单的进行排序，排序反而会消耗内存、时间，需要修改
        Collections.sort(fsDatasTemp, new Comparator<CMinute>() {
            @Override
            public int compare(CMinute cMinute, CMinute t1) {
                return new Long(cMinute.getTime()).compareTo(new Long(t1.getTime()));
            }
        });
        return fsDatasTemp;
    }

    //是否白盘和夜盘一起显示
    public static boolean hasNight(String duration) {
        if (duration.contains("|")) {
            return duration.split("\\|").length == 3;
        }
        return false;
    }

    /**
     * 解析开收盘时间点
     * @param duration 9:30-11:30|13:00-15:00(可能会有1、2、3段时间)
     * @return {"9:30", "11:30", "13:00", "15:00"}
     */
    public static ArrayList<String> getTimes(String duration) {

        ArrayList<String> result = new ArrayList<>();
        if(TextUtils.isEmpty(duration)) return result;
        try {
            if (duration.contains("|")) {
                String[] t1 = duration.split("\\|");
                for (String s : t1) {
                    result.add(s.split("-")[0]);
                    result.add(s.split("-")[1]);
                }

            } else {
                result.add(duration.split("-")[0]);
                result.add(duration.split("-")[1]);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 解析开收盘时间点
     * @param duration 9:30-11:30|13:00-15:00(可能会有1、2、3段时间)
     * @return {"9:30", "11:30", "13:00", "15:00"}
     */
    public static ArrayList<String> getTimes2(String duration) {
        ArrayList<String> result = new ArrayList<>();
        if(TextUtils.isEmpty(duration)) return result;
        if(duration.contains("|")) {
            String[] t1 = duration.split("\\|");
            for(String s : t1) {
                result.add(s.split("-")[0]);
                result.add(s.split("-")[1]);
            }
//            for(int i=0;i<t1.length;i++)
//            {
//                if(i==0)
//                {
//                    result.add(t1[i].split("-")[0]);
//                }
//                if(i==t1.length-1)
//                {
//                    result.add(t1[i].split("-")[1]);
//                }
//            }
        } else {
            result.add(duration.split("-")[0]);
            result.add(duration.split("-")[1]);
        }
        return result;
    }

    /**
     * 计算出Y轴显示价格的最大最小值
     * @param max
     * @param min
     * @param yd
     * @return
     */
    public static double[] getMaxAndMinByYd(double max, double min, double yd) {
        double limit = Math.abs(max - yd) > Math.abs(yd - min) ? Math.abs(max - yd) : Math.abs(yd - min);
        double[] result = new double[2];
        result[0] = yd + limit;
        result[1] = yd - limit;
        return result;
    }

    /**
     * 获取该画笔写出文字的高度
     * @param paint
     * @return
     */
    public static float getTextHeight(Paint paint) {
        Paint.FontMetrics fm = paint.getFontMetrics();
        return fm.descent - fm.ascent;
    }

    /**
     * 获取该画笔写出文字的宽度
     * @param paint
     * @return
     */
    public static float getTextWidth(Paint paint, String str) {
        return paint.measureText(str);
    }

    /**
     * 获取数组中最大最小值
     * @param list
     * @return
     */
    public static float[] getMaxAndMin(float[] list) {
        if(list == null || list.length == 0) return new float[]{0, 0};
        float max = 0,min =0;
        float[] temp = list.clone();
        Arrays.sort(temp);
        max = temp[temp.length - 1];
        for(int i=0;i<temp.length;i++)
        {
            if(temp[i]> StickData.defValue)
            {
                min = temp[i];
                break;
            }
        }

        return new float[] {max, min};
    }
    /**
     * 获取数组中最大最小值
     * @param list1
     * @return
     */
    public static float[] getMaxAndMin(float[] list1, float[] list2) {
        float max = 0, min = 0;
        float[] f1 = getMaxAndMin(list1);
        float[] f2 = getMaxAndMin(list2);
        max = f1[0] > f2[0] ? f1[0] : f2[0];
        min = f1[1] < f2[1] ? f1[1] : f2[1];
        return new float[] {max, min};
    }

    /**
     * 获取数组中最大最小值
     * @param list
     * @return
     */
    public static double[] getMaxAndMin2(double[] list) {
        if(list == null || list.length == 0) return new double[]{0, 0};
        double max = 0,min =0;
        double[] temp = list.clone();
        Arrays.sort(temp);
        max = temp[temp.length - 1];
        min = temp[0];
        return new double[] {max, min};
    }
    /**
     * 获取数组中最大最小值
     * @param list1
     * @return
     */
    public static double[] getMaxAndMin2(double[] list1,double[] list2) {
        double max = 0, min = 0;
        double[] f1 = getMaxAndMin2(list1);
        double[] f2 = getMaxAndMin2(list2);
        max = f1[0] > f2[0] ? f1[0] : f2[0];
        min = f1[1] < f2[1] ? f1[1] : f2[1];
        return new double[] {max, min};
    }

    /**
     * 获取数组中最大最小值
     * @param list1
     * @return
     */
    public static float[] getMaxAndMin(float[] list1,float[] list2, float[] list3) {
        float max = 0, min = 0;
        float[] f1 = getMaxAndMin(list1);
        float[] f2 = getMaxAndMin(list2);
        float[] f3 = getMaxAndMin(list3);
        max = f1[0] > f2[0] ? f1[0] : f2[0];
        max = max > f3[0] ? max : f3[0];
        min = f1[1] < f2[1] ? f1[1] : f2[1];
        min = min < f3[1] ? min : f3[1];
        return new float[] {max, min};
    }
    /**
     * 获取数组中最大最小值
     * @param list1
     * @return
     */
    public static double[] getMaxAndMin2(double[] list1, double[] list2, double[] list3) {
        double max = 0, min = 0;
        double[] f1 = getMaxAndMin2(list1);
        double[] f2 = getMaxAndMin2(list2);
        double[] f3 = getMaxAndMin2(list3);
        max = f1[0] > f2[0] ? f1[0] : f2[0];
        max = max > f3[0] ? max : f3[0];
        min = f1[1] < f2[1] ? f1[1] : f2[1];
        min = min < f3[1] ? min : f3[1];
        return new double[] {max, min};
    }
    /**
     * 获取数组中最大最小值
     * @param list1
     * @return
     */
    public static float[] getMaxAndMin(float[] list1, float[] list2,float[] list3, float[] list4) {
        float max = 0, min = 0;
        float[] f1 = getMaxAndMin(list1);
        float[] f2 = getMaxAndMin(list2);
        float[] f3 = getMaxAndMin(list3);
        float[] f4 = getMaxAndMin(list4);
        float[] f123 = getMaxAndMin(f1, f2, f3);
        max = f123[0] > f4[0] ? f123[0] : f4[0];
        min = f123[1] < f4[1] ? f123[1] : f4[1];
        return new float[] {max, min};
    }
    /**
     * 获取数组中最大最小值
     * @param list1
     * @return
     */
    public static double[] getMaxAndMin2(double[] list1, double[] list2,double[] list3, double[] list4) {
        double max = 0, min = 0;
        double[] f1 = getMaxAndMin2(list1);
        double[] f2 = getMaxAndMin2(list2);
        double[] f3 = getMaxAndMin2(list3);
        double[] f4 = getMaxAndMin2(list4);
        double[] f123 = getMaxAndMin2(f1, f2, f3);
        max = f123[0] > f4[0] ? f123[0] : f4[0];
        min = f123[1] < f4[1] ? f123[1] : f4[1];
        return new double[] {max, min};
    }
    /**
     * 获取数组中最大最小值
     * @param list1
     * @return
     */
    public static double[] getMaxAndMin3(double[] list1, double[] list2,double[] list3, double[] list4) {
        double max = 0, min = 0;
        double[] f1 = getMaxAndMin3(list1);
        double[] f2 = getMaxAndMin3(list2);
        double[] f3 = getMaxAndMin3(list3);
        double[] f4 = getMaxAndMin3(list4);
        double[] f123 = getMaxAndMin3(f1, f2, f3);
        max = f123[0] > f4[0] ? f123[0] : f4[0];
        min = f123[1] < f4[1] ? f123[1] : f4[1];
        return new double[] {max, min};
    }
    /**
     * 获取数组中最大最小值 最小值大于0
     * @param list
     * @return
     */
    public static double[] getMaxAndMin3(double[] list) {
        if(list == null || list.length == 0) return new double[]{0, 0};
        double max = 0,min =0;
        double[] temp = list.clone();
        Arrays.sort(temp);
        max = temp[temp.length - 1];
        min = temp[0];
        for(int i=0;i<temp.length;i++)
        {
            if(temp[i]>0)
            {
                min = temp[i];
                break;
            }
        }
        return new double[] {max, min};
    }
    /**
     * 获取数组中最大最小值
     * @param list1
     * @return
     */
    public static double[] getMaxAndMin3(double[] list1, double[] list2, double[] list3) {
        double max = 0, min = 0;
        double[] f1 = getMaxAndMin3(list1);
        double[] f2 = getMaxAndMin3(list2);
        double[] f3 = getMaxAndMin3(list3);
        max = f1[0] > f2[0] ? f1[0] : f2[0];
        max = max > f3[0] ? max : f3[0];
        min = f1[1] < f2[1] ? f1[1] : f2[1];
        min = min < f3[1] ? min : f3[1];
        return new double[] {max, min};
    }
}
